/*som.h
Définitions des structures utilisées pour le réseau neuronal.
Prototypes des fonctions.
Variables globales
version 2.0, Aout 2014
Roxane Levy
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mysql.h>
#include <math.h>


typedef struct Data Data ;   // pour les données d'apprentissage
struct Data {
	int N_L_input_V ;   // le nombre de vecteurs d'apprentissage
	int N ;             // la taille des vecteurs d'apprentissage
	float ** vecApprentissage ;   //la matrice N_L_input_V * N contenant les vecteurs d'apprentissage
} ;



typedef struct Net Net ;    // la map de Kohonen
struct Net {
   	float * captr ;       // input layer, reçoit le vecteur d'apprentissage
	int map_x,map_y ;        ; // dimension du réseau (largeur et longueur de la map)
	int neuroneSize ;   //équivalent à la taille des vecteurs d'apprentissage
	float *** RN  ;  // contient les neurones, soit une matrice map_x * map_y de vecteurs de même taille que les vecteurs d'apprentissage ( = neuroneSize)
	float ** activation_map ;    //une matrice pour contenir l'état d'activation des neurones
	float ** h ; //  une matrice pour la fonction de voisinage
    	int bmuCoord[1] ;   // pour contenir les coordonnées du bmu
	int attracteurs[1000][2] ;   // pour le calcul du bmu

};



typedef struct Options Options;
struct Options {
	int flagshuffle ;   // contrôle le chargement séquentiel ou désordonné
	int nb_iter ;   // le nombre d'itérations
	float initialSigma ;   // le rayon de voisinage initial
	float initialLearningRate ;   // le taux d'apprentissage initial
	int learningRateDecay ;       // le type de décroissance du taux d'apprentissage
	int typeNeighbourhood ;      // le type de voisinage
	float initC ;  // si l'apprentissage se fait par inverse temps, initC sera initialisé à = Ttotal / 100
	float alpha ; // taux d'apprentissage à l'instant t
        float sig ;    // rayon du voisinage à l'instant t
	float initial_epsi;   //  pour le voisinage en gaussienne positive
	float final_epsi ;    
	float final_sigma;
	float epsi ; 
       
} ;


/************** PROTOYPES DES FONCTIONS ************************/
void addArray(float array1[], float array2[], int sizeArray)  ;
void afficheActivationMap(Net *net) ;
void afficheData(Data * net);
void afficheNeighbourhood(Net * net)  ; 
void afficheRN(Net * net) ;
void affiche_vecteur(float vector[], int tailleVecteur) ;
void affiche_vecteurint(int vector[], int tailleVecteur) ;
int anotherRoutine () ; 
float euclidian(float vectorMap[], float vectorData[], int sizeVec)  ;
int destroyAll() ; 
void destroyRN() ;
void destroyRNandMore() ;
void destroyData () ;
void divideVecbyFloat(float vec[], float d, int vectorSize)  ;
void exponentialVec(float vec[], int vectorSize)  ; 
void findbestmatchingnode(Net * net) ;
float float_aleatoire_borne (float min, float max) ;
void genereVec(float * vec, int size) ;
float ** getData() ; 
float *** getRN() ; 
float ** getActiMap() ; 
void initialiseDatafromDatabase(Data * data, char * password, char * selection ) ;
void initNeighbourhoodVariable(Net * net,Options * options) ;
void initialiseRandomly(Data * data, Net * net) ;
void initialiseRNandMore(Net * net) ; 
void input_sequence() ;
void input_random(Data * data, Net * net, Options * options)  ;
int int_aleatoire(void) ;
int int_aleatoire_borne(int max) ;
void mapNeighbourhood(Net * net,Options * options)  ; 
int mainRoutine (char * password, char * selection) ;
int maxbetweenTwoints(int a, int b) ; 
void normalizeData(Data * data) ;
void normalizeRN(Net * net) ;
void normalizeVector(float vec[], int sizeVector)  ; 
float normeVec(float vec[] , int vectorSize) ;
void smallestvalue(Net * net) ;
float * substractArrayandMultiply(float r[], float array1[], float array2[], int sizeArray, float multiplier) ;
void shuffleVec(int sourceVecteur[], int tailleVecteur) ;   
int startprog(int a,int b, int c, int d, int e, int f, int g,int h) ; 
void subIntToVector(float vec[], int s, int vectorSize) ;
void power(float vec[], int s, int vectorSize) ; 
void update(Net * net, Options * options,int iteration) ;
void validateParameters(Data * data, Net * net, Options * options) ;
float distanceToNode(int bmu_x, int bmu_y, int w_x, int w_y) ;
int ** getBMUS() ; 
float  error_rate(Net * net) ;


/* LES GLOBALES */
int N_L_input_V ;
int N ;
int map_x ;
int map_y ;
int nbIter ;
int rateDecay ;
int typeNeigh  ; 
int flagshuffle ;


Data pointeurData ;
Data * mydata = &pointeurData ;

Net pointeurNet ;
Net * mynet = &pointeurNet ;

Options pointeurOptions;
Options * myoptions = &pointeurOptions ;

